package com.gf.framework.common.model;

import java.lang.reflect.Field;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.Stream;


/**
 * 字典接口
 * <p>
 * 自定义的字典枚举类实现本接口后可省略属性code和text，以及对应的get方法
 * 在构造方法中只需调用init方法即可初始化
 *
 * @author gaofei
 * @since 2022-05-22
 */
public interface IDict<KEY, VALUE> {

    /**
     * 通过code获取value
     *
     * @param clazz 枚举class
     * @param code  code
     * @return text
     */
    static <KEY, VALUE> VALUE getValueByCode(Class<? extends IDict<KEY, VALUE>> clazz, KEY code) {
        return Stream.of(clazz.getEnumConstants())
                .filter((IDict<KEY, VALUE> e) -> e.getCode().equals(code))
                .map(IDict::getValue)
                .findAny().orElse(null);
    }

    /**
     * 通过text获取code
     *
     * @param clazz 枚举class
     * @param value  value
     * @return code
     */
    static <KEY, VALUE> KEY getCodeByValue(Class<? extends IDict<KEY, VALUE>> clazz, VALUE value) {
        return Stream.of(clazz.getEnumConstants())
                .filter((IDict<KEY, VALUE> e) -> e.getValue().equals(value))
                .map(IDict::getCode)
                .findAny().orElse(null);
    }

    static <KEY, VALUE> Map<KEY, VALUE> toMap(Class<? extends IDict<KEY, VALUE>> clazz) {
        IDict<KEY, VALUE>[] enums = clazz.getEnumConstants();
        Map<KEY, VALUE> ret = new HashMap<>();
        for (IDict<KEY, VALUE> dict : enums) {
            ret.put(dict.getCode(), dict.getValue());
        }
        return ret;
    }

    /**
     * 通过code获取字典枚举实例
     *
     * @param clazz 枚举class
     * @param code  code
     * @param <KEY>   字典code类型
     * @param <R>   枚举类型
     * @return 字典枚举实例
     */
    @SuppressWarnings("unchecked")
    static <KEY, VALUE, R extends IDict<KEY, VALUE>> R getByCode(Class<? extends IDict<KEY, VALUE>> clazz, KEY code) {
        return Stream.of(clazz.getEnumConstants())
                .filter((IDict<KEY, VALUE> e) -> (e.getCode().equals(code)))
                .map(v -> (R) v)
                .findAny()
                .orElse(null);
    }

    /**
     * 获取给定的字典枚举项（常用下拉框数据请求）
     *
     * @param enums 可指定需要哪些项
     * @return List
     */
    @SafeVarargs
    static <KEY, VALUE, E extends IDict<KEY, VALUE>> List<IDict> getItems(E... enums) {
        return Stream.of(enums)
                .map(DictPool::getDict)
                .collect(Collectors.toList());
    }

    /**
     * 获取所有字典枚举项，除开指定的枚举
     *
     * @param exclude 指定排除的枚举
     * @return List
     */
    @SafeVarargs
    @SuppressWarnings("unchecked")
    static <KEY, VALUE, E extends IDict<KEY, VALUE>> List<IDict> getItemsExclude(E... exclude) {
        Class<IDict> clazz = (Class<IDict>) exclude.getClass().getComponentType();
        IDict<KEY, VALUE>[] allEnum = clazz.getEnumConstants();
        List<IDict> excludeList = Arrays.asList(exclude);
        return Stream.of(allEnum)
                .filter(e -> !excludeList.contains(e))
                .map(DictPool::getDict)
                .collect(Collectors.toList());
    }

    /**
     * 获取所有字典枚举项（常用下拉框数据请求）
     * 枚举值上标记@Deprecated的不会返回
     *
     * @param clazz 字典枚举类
     * @return List
     */
    static <KEY, VALUE> List<IDict<KEY, VALUE>> getAll(Class<? extends IDict<KEY, VALUE>> clazz) {
        Map<String, Field> fieldCache = Arrays.stream(clazz.getDeclaredFields()).
                filter(Field::isEnumConstant).
                collect(Collectors.toMap(Field::getName, Function.identity()));
        IDict<KEY, VALUE>[] allEnum = clazz.getEnumConstants();
        return Stream.of(allEnum)
                .filter(e -> !fieldCache.get(((Enum<?>) e).name()).isAnnotationPresent(Deprecated.class))
                .map(DictPool::getDict)
                .collect(Collectors.toList());
    }

    /**
     * 初始化
     *
     * @param code 字典编码
     * @param value 字典内容
     */
    default void init(KEY code, VALUE value) {
        DictPool.putDict(this, code, value);
    }

    /**
     * 获取编码
     */
    default KEY getCode() {
        return (KEY) DictPool.getDict(this).getCode();
    }

    /**
     * 获取文本
     */
    default VALUE getValue() {
        return DictPool.getDict(this).getValue();
    }


    class DictPool {
        private static final Map<IDict, DictBean> DICT_MAP = new ConcurrentHashMap<>();

        private static final Map<String, Class<? extends IDict>> DICT_NAME_CLASS_MAP = new ConcurrentHashMap<>();

        static <KEY, VALUE> void putDict(IDict<KEY, VALUE> dict, KEY code, VALUE value) {
            DICT_NAME_CLASS_MAP.put(dict.getClass().getName(), dict.getClass());
            DICT_MAP.put(dict, new DictBean<>(code, value));
        }

        public static <KEY, VALUE> List<IDict<KEY, VALUE>> getDict(String dictName) {
            Class<? extends IDict> aClass = DICT_NAME_CLASS_MAP.get(dictName);
            return IDict.getAll((Class<? extends IDict<KEY, VALUE>>) aClass);
        }

        static <KEY, VALUE, K extends IDict<KEY, VALUE>> DictBean<KEY, VALUE> getDict(K dict) {
            return DICT_MAP.get(dict);
        }
    }
}
